package com.module.ble.utils

import android.content.Context
import android.util.Base64
import android.util.Log
import androidx.work.CoroutineWorker
import androidx.work.WorkerParameters
import com.common.app.data.bean.CloudDownDataModel
import com.common.app.data.bean.UpKvDataModel
import com.common.app.helper.UserHelper
import com.common.app.utls.BrotliCompressionEx
import com.common.app.utls.report.ReportEventManager
import com.common.base.utils.JsonUtils
import com.module.ble.db.table.UserBloodOxygen
import com.module.ble.db.table.UserBodyTemperature
import com.module.ble.db.table.UserHeartRate
import com.module.ble.db.table.UserSleepInfo
import com.module.ble.db.table.UserSportRecord
import com.module.ble.db.table.UserStepsRelatedRecord
import com.module.ble.repo.UserStepsRelatedRecordRepo
import com.module.ble.utils.AizoSDKUtil.bloodOxygenMultiAdd2DB
import com.module.ble.utils.AizoSDKUtil.bodyTempMultiAdd2DB
import com.module.ble.utils.AizoSDKUtil.heartRateMultiAdd2DB
import com.module.ble.utils.AizoSDKUtil.sleepMultiAdd2DB
import com.module.ble.utils.AizoSDKUtil.sportsMultiAdd2DB
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

/**
 *
 * 作者：sosou
 *
 * 版本：1.0
 *
 * 创建日期：5/8/2025
 *
 * 描述：
 * 云端数据解压缩Worker
 * 负责从CloudDownDataDao获取数据，进行Base64解码和Brotli解压缩
 * 处理完成后删除已处理的数据
 *
 * 修订历史：
 * - 修复并发问题：确保每批数据完全处理完成后再进行下一批
 *
 */
class CloudDataDecompressionWorker(context: Context, params: WorkerParameters)
    : CoroutineWorker(context, params) {

    companion object {
        private const val TAG = "CloudDataDecompressionWorker"
        private const val BATCH_SIZE = 100 // 每次处理100条数据
    }

    override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
        try {
            Log.d(TAG, "开始云端数据解压缩任务")

            var processedCount = 0

            while (true) {
                // 每次从数据库获取100条数据
                val dataList = ReportEventManager.getCloudDownDataByIdDescSize(
                    UserHelper.getUserDbName(),
                    BATCH_SIZE
                )

                if (dataList.isEmpty()) {
                    Log.d(TAG, "没有更多数据需要处理，任务完成。总共处理了 $processedCount 条数据")
                    break
                }

                Log.d(TAG, "获取到 ${dataList.size} 条数据进行处理")

                // 存储成功解压的数据，用于后续删除
                val successfullyProcessedData = mutableListOf<CloudDownDataModel>()

                // 遍历每条数据进行解码和解压
                for (cloudData in dataList) {
                    try {
                        // 检查data字段是否为空
                        if (!cloudData.data.isNullOrEmpty()) {
                            // Base64解码
                            val decodedBytes = Base64.decode(cloudData.data, Base64.DEFAULT)

                            // Brotli解压缩
                            val decompressedString = BrotliCompressionEx.decompressToString(decodedBytes)

                            Log.d(TAG, "成功解压数据 ID: ${cloudData.id}, 解压后长度: ${decompressedString.length}")

                            // 确保业务处理完成后再继续
                            processDecompressedData(cloudData.type, decompressedString)

                            // 添加到成功处理列表
                            successfullyProcessedData.add(cloudData)

                        } else {
                            Log.w(TAG, "数据 ID: ${cloudData.id} 的data字段为空，跳过处理")
                            // 即使data为空，也将其添加到删除列表中
                            successfullyProcessedData.add(cloudData)
                        }

                    } catch (e: Exception) {
                        Log.e(TAG, "处理数据 ID: ${cloudData.id} 时发生错误: ${e.message}", e)
                        // 解压失败的数据不添加到删除列表，保留在数据库中
                    }
                }

                // 确保所有数据处理完成后再删除
                if (successfullyProcessedData.isNotEmpty()) {
                    Log.d(TAG, "准备删除 ${successfullyProcessedData.size} 条数据，ID列表: ${successfullyProcessedData.map { it.id }}")

                    ReportEventManager.delCloudDownData(successfullyProcessedData)

                    // 验证删除是否成功
                    val remainingData = ReportEventManager.getCloudDownDataByIdDescSize(UserHelper.getUserDbName(), 10)
                    Log.d(TAG, "删除后剩余数据数量: ${remainingData.size}, 前几条ID: ${remainingData.take(3).map { it.id }}")

                    processedCount += successfullyProcessedData.size
                    Log.d(TAG, "删除了 ${successfullyProcessedData.size} 条已处理的数据")
                }

                // 如果这批数据少于BATCH_SIZE，说明已经处理完所有数据
                if (dataList.size < BATCH_SIZE) {
                    Log.d(TAG, "已处理完所有数据，任务完成。总共处理了 $processedCount 条数据")
                    break
                }
            }

            Log.d(TAG, "云端数据解压缩任务完成")
            Result.success()

        } catch (e: Exception) {
            Log.e(TAG, "云端数据解压缩任务执行失败: ${e.message}", e)
            Result.failure()
        }
    }

    /**
     * 处理解压后的数据
     * 确保所有数据库操作完成后再返回
     */
    private suspend fun processDecompressedData(dataType: String?, decompressedString: String) {
        // 根据数据类型进行不同的处理
        Log.v(TAG, "解压后的数据内容: $decompressedString")
        val mData: List<UpKvDataModel> = JsonUtils.fromJsonList(decompressedString)
        Log.d(TAG, "处理解压数据 - 类型: ${dataType}, size:${mData.size}条数据，timestamp列表: ${mData.map { it.timestamp }}")

        // 根据数据类型进行处理，确保数据库操作完成
        when (dataType) {
            ServerHealthDataModelType.HEARTRATE.value -> {
                val hrData = arrayListOf<UserHeartRate>()
                mData.forEach {
                    JsonUtils.fromJson(it.value ?: "", UserHeartRate::class.java)?.let { beanIt ->
                        beanIt.sysStat = 1
                        hrData.add(beanIt)
                    }
                }
                // 确保数据库操作完成
                withContext(Dispatchers.IO) {
                    heartRateMultiAdd2DB(hrData)
                }
            }
            ServerHealthDataModelType.BLOODOXYGEN.value -> {
                val oxyData = arrayListOf<UserBloodOxygen>()
                mData.forEach {
                    JsonUtils.fromJson(it.value ?: "", UserBloodOxygen::class.java)?.let { beanIt ->
                        beanIt.sysStat = 1
                        oxyData.add(beanIt)
                    }
                }
                // 确保数据库操作完成
                withContext(Dispatchers.IO) {
                    bloodOxygenMultiAdd2DB(oxyData)
                }
            }
            ServerHealthDataModelType.BODYTEMP.value -> {
                val tmpData = arrayListOf<UserBodyTemperature>()
                mData.forEach {
                    JsonUtils.fromJson(it.value ?: "", UserBodyTemperature::class.java)
                        ?.let { beanIt ->
                            beanIt.sysStat = 1
                            tmpData.add(beanIt)
                        }
                }
                // 确保数据库操作完成
                withContext(Dispatchers.IO) {
                    bodyTempMultiAdd2DB(tmpData)
                }
            }
            ServerHealthDataModelType.STEPS.value -> {
                val stepsData = arrayListOf<UserStepsRelatedRecord>()
                mData.forEach {
                    JsonUtils.fromJson(it.value ?: "", UserStepsRelatedRecord::class.java)
                        ?.let { beanIt ->
                            beanIt.sysStat = 1
                            stepsData.add(beanIt)
                        }
                }
                // 确保数据库操作完成
                withContext(Dispatchers.IO) {
                    UserStepsRelatedRecordRepo.instance.insertDistinct(stepsData)
                }
            }
            ServerHealthDataModelType.EXERCISE.value -> {
                val sportData = arrayListOf<UserSportRecord>()
                mData.forEach {
                    JsonUtils.fromJson(it.value ?: "", UserSportRecord::class.java)?.let { beanIt ->
                        beanIt.sysStat = 1
                        sportData.add(beanIt)
                    }
                }
                // 确保数据库操作完成
                withContext(Dispatchers.IO) {
                    sportsMultiAdd2DB(sportData)
                }
            }
            ServerHealthDataModelType.SLEEP.value -> {
                val sleepData = arrayListOf<UserSleepInfo>()
                mData.forEach {
                    JsonUtils.fromJson(it.value ?: "", UserSleepInfo::class.java)?.let { beanIt ->
                        beanIt.sysStat = 1
                        sleepData.add(beanIt)
                    }
                }
                // 确保数据库操作完成
                withContext(Dispatchers.IO) {
                    sleepMultiAdd2DB(sleepData)
                }
            }
            else -> {
                Log.w(TAG, "未知的数据类型: $dataType")
            }
        }

        Log.d(TAG, "数据类型 $dataType 的业务处理完成")
    }
}